home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / rdma / rdma_cm.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  11.0 KB  |  334 lines
  1. /*
  2.  * Copyright (c) 2005 Voltaire Inc.  All rights reserved.
  3.  * Copyright (c) 2005 Intel Corporation.  All rights reserved.
  4.  *
  5.  * This software is available to you under a choice of one of two
  6.  * licenses.  You may choose to be licensed under the terms of the GNU
  7.  * General Public License (GPL) Version 2, available from the file
  8.  * COPYING in the main directory of this source tree, or the
  9.  * OpenIB.org BSD license below:
  10.  *
  11.  *     Redistribution and use in source and binary forms, with or
  12.  *     without modification, are permitted provided that the following
  13.  *     conditions are met:
  14.  *
  15.  *      - Redistributions of source code must retain the above
  16.  *        copyright notice, this list of conditions and the following
  17.  *        disclaimer.
  18.  *
  19.  *      - Redistributions in binary form must reproduce the above
  20.  *        copyright notice, this list of conditions and the following
  21.  *        disclaimer in the documentation and/or other materials
  22.  *        provided with the distribution.
  23.  *
  24.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  25.  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  26.  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  27.  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  28.  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  29.  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  30.  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  31.  * SOFTWARE.
  32.  */
  33.  
  34. #if !defined(RDMA_CM_H)
  35. #define RDMA_CM_H
  36.  
  37. #include <linux/socket.h>
  38. #include <linux/in6.h>
  39. #include <rdma/ib_addr.h>
  40. #include <rdma/ib_sa.h>
  41.  
  42. /*
  43.  * Upon receiving a device removal event, users must destroy the associated
  44.  * RDMA identifier and release all resources allocated with the device.
  45.  */
  46. enum rdma_cm_event_type {
  47.     RDMA_CM_EVENT_ADDR_RESOLVED,
  48.     RDMA_CM_EVENT_ADDR_ERROR,
  49.     RDMA_CM_EVENT_ROUTE_RESOLVED,
  50.     RDMA_CM_EVENT_ROUTE_ERROR,
  51.     RDMA_CM_EVENT_CONNECT_REQUEST,
  52.     RDMA_CM_EVENT_CONNECT_RESPONSE,
  53.     RDMA_CM_EVENT_CONNECT_ERROR,
  54.     RDMA_CM_EVENT_UNREACHABLE,
  55.     RDMA_CM_EVENT_REJECTED,
  56.     RDMA_CM_EVENT_ESTABLISHED,
  57.     RDMA_CM_EVENT_DISCONNECTED,
  58.     RDMA_CM_EVENT_DEVICE_REMOVAL,
  59.     RDMA_CM_EVENT_MULTICAST_JOIN,
  60.     RDMA_CM_EVENT_MULTICAST_ERROR,
  61.     RDMA_CM_EVENT_ADDR_CHANGE,
  62.     RDMA_CM_EVENT_TIMEWAIT_EXIT
  63. };
  64.  
  65. enum rdma_port_space {
  66.     RDMA_PS_SDP   = 0x0001,
  67.     RDMA_PS_IPOIB = 0x0002,
  68.     RDMA_PS_TCP   = 0x0106,
  69.     RDMA_PS_UDP   = 0x0111,
  70.     RDMA_PS_SCTP  = 0x0183
  71. };
  72.  
  73. struct rdma_addr {
  74.     struct sockaddr_storage src_addr;
  75.     struct sockaddr_storage dst_addr;
  76.     struct rdma_dev_addr dev_addr;
  77. };
  78.  
  79. struct rdma_route {
  80.     struct rdma_addr addr;
  81.     struct ib_sa_path_rec *path_rec;
  82.     int num_paths;
  83. };
  84.  
  85. struct rdma_conn_param {
  86.     const void *private_data;
  87.     u8 private_data_len;
  88.     u8 responder_resources;
  89.     u8 initiator_depth;
  90.     u8 flow_control;
  91.     u8 retry_count;        /* ignored when accepting */
  92.     u8 rnr_retry_count;
  93.     /* Fields below ignored if a QP is created on the rdma_cm_id. */
  94.     u8 srq;
  95.     u32 qp_num;
  96. };
  97.  
  98. struct rdma_ud_param {
  99.     const void *private_data;
  100.     u8 private_data_len;
  101.     struct ib_ah_attr ah_attr;
  102.     u32 qp_num;
  103.     u32 qkey;
  104. };
  105.  
  106. struct rdma_cm_event {
  107.     enum rdma_cm_event_type     event;
  108.     int             status;
  109.     union {
  110.         struct rdma_conn_param    conn;
  111.         struct rdma_ud_param    ud;
  112.     } param;
  113. };
  114.  
  115. struct rdma_cm_id;
  116.  
  117. /**
  118.  * rdma_cm_event_handler - Callback used to report user events.
  119.  *
  120.  * Notes: Users may not call rdma_destroy_id from this callback to destroy
  121.  *   the passed in id, or a corresponding listen id.  Returning a
  122.  *   non-zero value from the callback will destroy the passed in id.
  123.  */
  124. typedef int (*rdma_cm_event_handler)(struct rdma_cm_id *id,
  125.                      struct rdma_cm_event *event);
  126.  
  127. struct rdma_cm_id {
  128.     struct ib_device    *device;
  129.     void            *context;
  130.     struct ib_qp        *qp;
  131.     rdma_cm_event_handler     event_handler;
  132.     struct rdma_route     route;
  133.     enum rdma_port_space     ps;
  134.     u8             port_num;
  135. };
  136.  
  137. /**
  138.  * rdma_create_id - Create an RDMA identifier.
  139.  *
  140.  * @event_handler: User callback invoked to report events associated with the
  141.  *   returned rdma_id.
  142.  * @context: User specified context associated with the id.
  143.  * @ps: RDMA port space.
  144.  */
  145. struct rdma_cm_id *rdma_create_id(rdma_cm_event_handler event_handler,
  146.                   void *context, enum rdma_port_space ps);
  147.  
  148. /**
  149.   * rdma_destroy_id - Destroys an RDMA identifier.
  150.   *
  151.   * @id: RDMA identifier.
  152.   *
  153.   * Note: calling this function has the effect of canceling in-flight
  154.   * asynchronous operations associated with the id.
  155.   */
  156. void rdma_destroy_id(struct rdma_cm_id *id);
  157.  
  158. /**
  159.  * rdma_bind_addr - Bind an RDMA identifier to a source address and
  160.  *   associated RDMA device, if needed.
  161.  *
  162.  * @id: RDMA identifier.
  163.  * @addr: Local address information.  Wildcard values are permitted.
  164.  *
  165.  * This associates a source address with the RDMA identifier before calling
  166.  * rdma_listen.  If a specific local address is given, the RDMA identifier will
  167.  * be bound to a local RDMA device.
  168.  */
  169. int rdma_bind_addr(struct rdma_cm_id *id, struct sockaddr *addr);
  170.  
  171. /**
  172.  * rdma_resolve_addr - Resolve destination and optional source addresses
  173.  *   from IP addresses to an RDMA address.  If successful, the specified
  174.  *   rdma_cm_id will be bound to a local device.
  175.  *
  176.  * @id: RDMA identifier.
  177.  * @src_addr: Source address information.  This parameter may be NULL.
  178.  * @dst_addr: Destination address information.
  179.  * @timeout_ms: Time to wait for resolution to complete.
  180.  */
  181. int rdma_resolve_addr(struct rdma_cm_id *id, struct sockaddr *src_addr,
  182.               struct sockaddr *dst_addr, int timeout_ms);
  183.  
  184. /**
  185.  * rdma_resolve_route - Resolve the RDMA address bound to the RDMA identifier
  186.  *   into route information needed to establish a connection.
  187.  *
  188.  * This is called on the client side of a connection.
  189.  * Users must have first called rdma_resolve_addr to resolve a dst_addr
  190.  * into an RDMA address before calling this routine.
  191.  */
  192. int rdma_resolve_route(struct rdma_cm_id *id, int timeout_ms);
  193.  
  194. /**
  195.  * rdma_create_qp - Allocate a QP and associate it with the specified RDMA
  196.  * identifier.
  197.  *
  198.  * QPs allocated to an rdma_cm_id will automatically be transitioned by the CMA
  199.  * through their states.
  200.  */
  201. int rdma_create_qp(struct rdma_cm_id *id, struct ib_pd *pd,
  202.            struct ib_qp_init_attr *qp_init_attr);
  203.  
  204. /**
  205.  * rdma_destroy_qp - Deallocate the QP associated with the specified RDMA
  206.  * identifier.
  207.  *
  208.  * Users must destroy any QP associated with an RDMA identifier before
  209.  * destroying the RDMA ID.
  210.  */
  211. void rdma_destroy_qp(struct rdma_cm_id *id);
  212.  
  213. /**
  214.  * rdma_init_qp_attr - Initializes the QP attributes for use in transitioning
  215.  *   to a specified QP state.
  216.  * @id: Communication identifier associated with the QP attributes to
  217.  *   initialize.
  218.  * @qp_attr: On input, specifies the desired QP state.  On output, the
  219.  *   mandatory and desired optional attributes will be set in order to
  220.  *   modify the QP to the specified state.
  221.  * @qp_attr_mask: The QP attribute mask that may be used to transition the
  222.  *   QP to the specified state.
  223.  *
  224.  * Users must set the @qp_attr->qp_state to the desired QP state.  This call
  225.  * will set all required attributes for the given transition, along with
  226.  * known optional attributes.  Users may override the attributes returned from
  227.  * this call before calling ib_modify_qp.
  228.  *
  229.  * Users that wish to have their QP automatically transitioned through its
  230.  * states can associate a QP with the rdma_cm_id by calling rdma_create_qp().
  231.  */
  232. int rdma_init_qp_attr(struct rdma_cm_id *id, struct ib_qp_attr *qp_attr,
  233.                int *qp_attr_mask);
  234.  
  235. /**
  236.  * rdma_connect - Initiate an active connection request.
  237.  * @id: Connection identifier to connect.
  238.  * @conn_param: Connection information used for connected QPs.
  239.  *
  240.  * Users must have resolved a route for the rdma_cm_id to connect with
  241.  * by having called rdma_resolve_route before calling this routine.
  242.  *
  243.  * This call will either connect to a remote QP or obtain remote QP
  244.  * information for unconnected rdma_cm_id's.  The actual operation is
  245.  * based on the rdma_cm_id's port space.
  246.  */
  247. int rdma_connect(struct rdma_cm_id *id, struct rdma_conn_param *conn_param);
  248.  
  249. /**
  250.  * rdma_listen - This function is called by the passive side to
  251.  *   listen for incoming connection requests.
  252.  *
  253.  * Users must have bound the rdma_cm_id to a local address by calling
  254.  * rdma_bind_addr before calling this routine.
  255.  */
  256. int rdma_listen(struct rdma_cm_id *id, int backlog);
  257.  
  258. /**
  259.  * rdma_accept - Called to accept a connection request or response.
  260.  * @id: Connection identifier associated with the request.
  261.  * @conn_param: Information needed to establish the connection.  This must be
  262.  *   provided if accepting a connection request.  If accepting a connection
  263.  *   response, this parameter must be NULL.
  264.  *
  265.  * Typically, this routine is only called by the listener to accept a connection
  266.  * request.  It must also be called on the active side of a connection if the
  267.  * user is performing their own QP transitions.
  268.  *
  269.  * In the case of error, a reject message is sent to the remote side and the
  270.  * state of the qp associated with the id is modified to error, such that any
  271.  * previously posted receive buffers would be flushed.
  272.  */
  273. int rdma_accept(struct rdma_cm_id *id, struct rdma_conn_param *conn_param);
  274.  
  275. /**
  276.  * rdma_notify - Notifies the RDMA CM of an asynchronous event that has
  277.  * occurred on the connection.
  278.  * @id: Connection identifier to transition to established.
  279.  * @event: Asynchronous event.
  280.  *
  281.  * This routine should be invoked by users to notify the CM of relevant
  282.  * communication events.  Events that should be reported to the CM and
  283.  * when to report them are:
  284.  *
  285.  * IB_EVENT_COMM_EST - Used when a message is received on a connected
  286.  *    QP before an RTU has been received.
  287.  */
  288. int rdma_notify(struct rdma_cm_id *id, enum ib_event_type event);
  289.  
  290. /**
  291.  * rdma_reject - Called to reject a connection request or response.
  292.  */
  293. int rdma_reject(struct rdma_cm_id *id, const void *private_data,
  294.         u8 private_data_len);
  295.  
  296. /**
  297.  * rdma_disconnect - This function disconnects the associated QP and
  298.  *   transitions it into the error state.
  299.  */
  300. int rdma_disconnect(struct rdma_cm_id *id);
  301.  
  302. /**
  303.  * rdma_join_multicast - Join the multicast group specified by the given
  304.  *   address.
  305.  * @id: Communication identifier associated with the request.
  306.  * @addr: Multicast address identifying the group to join.
  307.  * @context: User-defined context associated with the join request, returned
  308.  * to the user through the private_data pointer in multicast events.
  309.  */
  310. int rdma_join_multicast(struct rdma_cm_id *id, struct sockaddr *addr,
  311.             void *context);
  312.  
  313. /**
  314.  * rdma_leave_multicast - Leave the multicast group specified by the given
  315.  *   address.
  316.  */
  317. void rdma_leave_multicast(struct rdma_cm_id *id, struct sockaddr *addr);
  318.  
  319. /**
  320.  * rdma_set_service_type - Set the type of service associated with a
  321.  *   connection identifier.
  322.  * @id: Communication identifier to associated with service type.
  323.  * @tos: Type of service.
  324.  *
  325.  * The type of service is interpretted as a differentiated service
  326.  * field (RFC 2474).  The service type should be specified before
  327.  * performing route resolution, as existing communication on the
  328.  * connection identifier may be unaffected.  The type of service
  329.  * requested may not be supported by the network to all destinations.
  330.  */
  331. void rdma_set_service_type(struct rdma_cm_id *id, int tos);
  332.  
  333. #endif /* RDMA_CM_H */
  334.